#! /usr/bin/env python
# -*- coding: utf-8 -*-


"""
 *
 * - Ime
 *
 *  - kratki opis
 *
 * Autori: Koki007
 * Verzija: 0.1
 * Datum: 05.01.2011
 *
"""

import ConfigParser
import pygame
from pygame.locals import *

import os

from tajmer import cTajmer

# Koristi se za animiranje spritesheeta
class cAnimacija:

    def __init__(self, zaglavlje = 0, flip = 0):


        self.frameovi = []  #lista slika(surface) iz ucitanog spritesheet
        self.animacije = {}  # lista animacija, key je ime animacije, vrijednost je brojcani popis frameova

        self.trenutna_slika = 0 # trenutni frame za crtanje

        self.aktivna_animacija = 0 # koja animacija je trenutno aktivna - sadrzi listu frameova
        self.trenutni_frame = 0 #trenutni frame unutar pokrenute animacije
        self.u_petlji = False

        self.tajmer = cTajmer(1, 1) # tajmer koji broji kada treba promjeniti frame
        
        if zaglavlje: self.ucitaj_zaglavlje(zaglavlje, flip)
        pass


    def azuriraj(self):
        if self.aktivna_animacija:
            
            # ako je proslo vrijeme jednog framea - kazi na sljedeci frame
            if self.tajmer.azuriraj():
                
                # ako se doslo do zadnjeg framea u listi
                if self.trenutni_frame == len(self.aktivna_animacija) - 1:
                    
                    if self.u_petlji: self.trenutni_frame = 0 #kreni od prvog framea
                    else: 
                        self.aktivna_animacija = False #nema aktivne animacije, izlazi van iz metode
                        return
                
                # ako nije zadnji frame kazi na sljedeci frame
                else: self.trenutni_frame += 1

                # azuriraj trenutnu sliku koja se treba crtati na temelju novog frame indeksa
                self.trenutna_slika = self.aktivna_animacija[self.trenutni_frame]




    def crtaj(self):
        #print "Trenutni frame: ", self.trenutna_slika
        return self.frameovi[self.trenutna_slika]


    def pokreni_animaciju(self, ime_animacije, brzina, u_petlji = 0):
		#print self.aktivna_animacija
		if not self.aktivna_animacija:
			self.aktivna_animacija = self.animacije[ime_animacije]
			self.u_petlji = u_petlji
			self.trenutni_frame = 0

			#racunanje trajanje jednog frame-a
			trajanje_framea = 1.0 / brzina * 1000
			self.tajmer.postavi_vrijeme(trajanje_framea)
			self.tajmer.pokreni()

			# pointer na trenutni frame u listi slika pokazuje na prvi frame animacije
			self.trenutna_slika = self.aktivna_animacija[0]

    def pauziraj_animaciju(self):
        pass

    def zaustavi_animaciju(self):
        self.aktivna_animacija = False
        pass

    def ucitaj_zaglavlje(self, datoteka, flip = 0):
        parser = ConfigParser.ConfigParser()
        parser.readfp(open(datoteka))
        
        direktorij = os.path.dirname(datoteka)

        #print parser.get("ZAGLAVLJE", "VRSTA")
        #print parser.get("ZAGLAVLJE", "VERZIJA")

        ime_datoteke = parser.get("SLIKA", "DATOTEKA")
        ime_datoteke = os.path.join(direktorij, ime_datoteke)
        velicina_x = parser.getint("SLIKA", "VELICINA_X")
        velicina_y = parser.getint("SLIKA", "VELICINA_Y")
        broj_slika = parser.getint("SLIKA", "BROJ_SLIKA")
        
        self.ucitaj_sliku(ime_datoteke, velicina_x, velicina_y, broj_slika, flip)
        
        # provjeravanje liste animacija i dodavanje
        animacije = parser.options("ANIMACIJE")
        for animacija in animacije:
            lista_frameova = parser.get("ANIMACIJE", animacija)
            lista_frameova = lista_frameova.split(" ")
            
            # sada je u lista_frameova lista string brojeva, pa cemo ih pretvoriti u listu int brojeva
            for i in range( len(lista_frameova) ):
                lista_frameova[i] = int( lista_frameova[i] )
                
            self.dodaj_animaciju(animacija, lista_frameova)
        pass


    def ucitaj_sliku(self, spritesheet, velicina_x, velicina_y, broj_slika, flip = 0):
        
        spritesheet = pygame.image.load(spritesheet).convert_alpha()
        if flip: spritesheet = pygame.transform.flip(spritesheet, True, False)

        for x in range(broj_slika):
            # stvori prazni surface
            slika = pygame.Surface((velicina_x, velicina_y), SRCALPHA)
            # stvori rect iz kojeg dijela spritesheeta da se uzme frame
            rect = pygame.Rect(x * velicina_x, 0, velicina_x, velicina_y)
            # popuni stvoreni frame
            slika.blit(spritesheet, (0,0), rect)
            self.frameovi.append(slika)

        #self.trenutna_slika = self.frameovi[0]
    
    # prvi argument je ime sa kojoj se poslije poziva animacija, a drugi argument je lista brojeva/frameova, raspored framova u animaciji
    def dodaj_animaciju(self, ime, lista_slika):
        self.animacije[ime] = lista_slika
        
        
    def get_rect(self, **kwargs):
		return self.frameovi[self.trenutna_slika].get_rect(**kwargs)


    # problem - surface sa alfa kanalom se ne moze fade-ati sa set_alpha metodom, mora se pixel po pixel
    # najednostavnije i najbrze rijesenje bi bilo ne koristiti slike sa alfa kanalom i rucno zadati colorkey boju
    # TODO: dodati mogucnost odabira colorkey boje za spritesheete (u headeru) i implementirati ovu set_alpha metodu
    def set_alpha(self, vrijednost):
        pass


### ZA TESTIRANJE
if __name__ == "__main__":
    import pygame
    from pygame.locals import *
    from sys import exit

    pygame.init()
    glavni_buffer = pygame.display.set_mode((800, 600), DOUBLEBUF)
    glavna_petlja = True

    animacija = cAnimacija()
    animacija.ucitaj_sliku("../toadrunning.png", 40, 27, 5)
    #animacija.ucitaj_zaglavlje("toad_animacija.txt")
    
    animacija.dodaj_animaciju("trcanje", [0,1,2,3,4])
    animacija.pokreni_animaciju("trcanje", 5, 0)

    animacija_upetlji = cAnimacija()
    animacija_upetlji.ucitaj_sliku("../toadrunning.png", 40, 27, 5)
    animacija_upetlji.dodaj_animaciju("trcanje", [0,1,2,3,4])
    animacija_upetlji.pokreni_animaciju("trcanje", 10, 1)

    spritesheet = pygame.image.load("../toadrunning.png").convert_alpha()

    while True:# glavna_petlja == True:

        # INPUT
        for event in pygame.event.get():
            if event.type == QUIT:
                exit()

            if event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    glavna_petlja = False

                if event.key == K_SPACE:
                    glavna_petlja = animacija.pokreni_animaciju("trcanje", 2, 0)
                    
                if event.key == K_s:
                    glavna_petlja = animacija.zaustavi_animaciju()
                    
        pritsnute_tipke = pygame.key.get_pressed()
        if pritsnute_tipke[K_LEFT]: 
            animacija.pokreni_animaciju("trcanje", 20, 0)

        # AZURIRANJE
        animacija_upetlji.azuriraj()
        animacija.azuriraj()

        # CRTANJE
        glavni_buffer.fill((0, 50, 0))
        glavni_buffer.blit( animacija_upetlji.crtaj(), (200, 200) )
        glavni_buffer.blit( animacija.crtaj(), (200, 250) )
        glavni_buffer.blit( spritesheet, (100, 100) )

        for i in range(5):
            glavni_buffer.blit( animacija.frameovi[i], (100, i * 50 + 200 ) )

        pygame.display.flip()

